package cn.xy.commons.util;

import cn.hutool.core.text.CharSequenceUtil;
import cn.hutool.core.util.NumberUtil;
import cn.hutool.core.util.StrUtil;
import cn.xy.commons.constant.Charsets;
import cn.xy.commons.constant.Consts;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 字符串处理工具类<br>
 * 扩展了hutool的StrUtil
 *
 *  @author xy
 */
public class StringUtil extends StrUtil {

    /**
     * 字符串拼接
     *
     * @param args args
     * @return result
     */
    public static String concat(final Object... args) {
        StringBuilder str = new StringBuilder();
        for (Object arg : args) {
            str.append(arg);
        }
        return str.toString();
    }

    /**
     * urlEncode
     *
     * @param str    str
     * @param coding coding
     * @return result
     */
    public static String encode(final String str, final String coding) {
        if (isEmpty(str)) {
            return Consts.EMPTY;
        }
        try {
            return java.net.URLEncoder.encode(str, coding);
        } catch (Exception e) {
            return str;
        }
    }

    /**
     * utf8 urlEncode
     *
     * @param str str
     * @return result
     */
    public static String encode(final String str) {
        return encode(str, Charsets.UTF_8);
    }

    /**
     * 字符串 url解密
     *
     * @param str    字符串
     * @param coding 编码
     * @return 解码后的字符串
     */
    public static String urlDecode(final String str, final String coding) {
        if (isEmpty(str)) {
            return Consts.EMPTY;
        }
        try {
            return java.net.URLDecoder.decode(str, coding);
        } catch (Exception e) {
            return str;
        }
    }

    /**
     * utf8 url编码
     *
     * @param str 字符串
     * @return 编码后的字符串
     */
    public static String urlDecode(final String str) {
        return urlDecode(str, Charsets.UTF_8);
    }

    /**
     * 删除数字字符串中小数点后多余的0
     * example: 1.0010 -> 1.001  1.00 -> 1
     *
     * @param str 字符串
     * @return 处理后的字符串
     */
    public static String removeExtraZero(String str) {
        if (CharSequenceUtil.isEmpty(str)) {
            return str;
        }
        if (str.indexOf(Consts.DOT) >= 0) {
            str = str.replaceAll("0+$", "");
            str = str.replaceAll("[.]$", "");
        }
        return str;
    }

    /**
     * 向前补零
     *
     * @param str       字符串
     * @param strLength 字符串长度
     * @return 补零后的字符串
     */
    public static String addZeroForNum(String str, int strLength) {
        StringBuilder strBuilder = new StringBuilder(str);
        int strLen = str.length();
        if (strLen < strLength) {
            while (strLen < strLength) {
                // 左补0
                strBuilder = new StringBuilder("0" + strBuilder);
                strLen = strBuilder.length();
            }
        }
        return strBuilder.toString();
    }


    /**
     * 向前补零
     *
     * @param str       字符串
     * @param strLength 字符串长度
     * @return 补零后的字符串
     */
    public static String addZeroForNum(long str, int strLength) {
        return StringUtil.addZeroForNum(String.valueOf(str), strLength);
    }

    /**
     * 将字符串分割成数组（会去重及过滤掉空字符）
     *
     * @param str   字符串
     * @param regex 分隔符
     * @return 字符串列表
     */
    public static List<String> splitToList(String str, String regex) {
        if (CharSequenceUtil.isEmpty(str)) {
            return new ArrayList<>();
        }
        return Arrays.stream(str.split(regex)).filter(StringUtil::isNotEmpty).distinct().collect(Collectors.toList());
    }

    /**
     * 将字符串分割成数组（会去重及过滤掉空字符）
     *
     * @param str 字符串
     * @return 字符串列表
     */
    public static List<String> splitToList(String str) {
        return StringUtil.splitToList(str, Consts.COMMA);
    }

    /**
     * 将字符串分割成数组（会过滤掉非数字字符）
     *
     * @param str   字符串
     * @param regex 分隔符
     * @return 字符串列表
     */
    public static List<Integer> splitToIntegerList(String str, String regex) {
        if (CharSequenceUtil.isEmpty(str)) {
            return new ArrayList<>();
        }
        return Arrays.stream(str.split(regex)).filter(NumberUtil::isInteger).map(Integer::parseInt).collect(Collectors.toList());
    }

    /**
     * 将字符串分割成数组（会过滤掉非数字字符）
     *
     * @param str 字符串
     * @return 字符串列表
     */
    public static List<Integer> splitToIntegerList(String str) {
        return StringUtil.splitToIntegerList(str, Consts.COMMA);
    }

    /**
     * 将字符串分割成数组（会过滤掉非数字字符）
     *
     * @param str   字符串
     * @param regex 分隔符
     * @return 字符串列表
     */
    public static List<Long> splitToLongList(String str, String regex) {
        if (CharSequenceUtil.isEmpty(str)) {
            return new ArrayList<>();
        }
        return Arrays.stream(str.split(regex)).filter(NumberUtil::isLong).map(Long::parseLong).collect(Collectors.toList());
    }

    /**
     * 将字符串分割成数组（会过滤掉非数字字符）
     *
     * @param str 字符串
     * @return 字符串列表
     */
    public static List<Long> splitToLongList(String str) {
        return StringUtil.splitToLongList(str, Consts.COMMA);
    }

}
